# -*- coding: utf-8 -*-
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.http import HttpResponse, HttpResponseRedirect
from django.contrib.auth.models import *
from bd42.apps.bdig.forms import *
from bd42.apps.bdig.models import *
from datetime import date, datetime
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.decorators import login_required, permission_required
from django.db.models import Q
from django.core.urlresolvers import reverse
import re

@login_required()
def adm(request):
    """
    Função de administração do site
    """
    return render_to_response('adm/adm.html', context_instance=RequestContext(request))

def index(request):
    """
    Função responsável pela página inicial e pela consulta de trabalhos publicados
    """
    if 'pesquisa' in request.GET:
        pesquisa = request.GET['pesquisa']
        
        exclusao = [',', '.', '!', ':', ';', '?',]
        
        troca_por_espaco = [
            'para', 'por', 'de', 'da', 'do', 'das', 'dos', u'são', 'seus',
            'suas', 'sua', 'seu', 'com', 'como',  'o', 'a', 'ao', 'e', '-',
            'no', 'na', 'em', 'um', 'uma', 'uns', 'umas', 'ou', 'os', 'as',
            'aos', 'nas', 'nos', 'qual', 'quais', 'que', u'é', u'à', 'pela'
        ]
        
        pesquisa = p = pesquisa.lower()
        
        for e in exclusao:
            pesquisa = pesquisa.replace(e, '')
        
        pesquisa = [x for x in pesquisa.rsplit(r" ") if x != '']

        for t in troca_por_espaco:
            c = pesquisa.count(t)
            for i in range(0, c):
                try:
                    pesquisa.remove(t)
                except Exception, e:
                    pass
        
        object_list_pesquisa = []
        
        for chave in pesquisa:
            object_list_chave = Trabalho.objects.filter(
                Q(workflow='publicado'),       
                Q(titulo__icontains = chave) | Q(titulo__istartswith = chave) | Q(titulo__iendswith = chave) |
                Q(resumo__icontains = chave) | Q(resumo__istartswith = chave) | Q(resumo__iendswith = chave) |
                Q(title__icontains = chave) | Q(title__istartswith = chave) | Q(title__iendswith = chave) |
                Q(abstract__icontains = chave) | Q(abstract__istartswith = chave) | Q(abstract__iendswith = chave) |
                Q(palavrasChave__icontains = chave) | Q(palavrasChave__istartswith = chave) | Q(palavrasChave__iendswith = chave) |
                Q(keywords__icontains = chave) | Q(keywords__istartswith = chave) | Q(keywords__iendswith = chave)
            )
            for chave in object_list_chave:
                if not(chave in object_list_pesquisa):
                    object_list_pesquisa.append(chave)
        
        return render_to_response(
            'index.html',
            {
                'pesquisa' : p,
                'object_list_pesquisa' : object_list_pesquisa,
            },
            context_instance=RequestContext(request)
        )
    else:
        return render_to_response(
            'index.html', context_instance=RequestContext(request)
        )

@login_required()
def perfil(request):
    """
    Função responsável pela edição de perfil
    """
    resultado = False
    
    if request.method == 'POST':
        formulario = FormularioUsuario(request.POST)
        del(formulario.fields['username'])
        del(formulario.fields['password'])
        
        if formulario.is_valid():
            user = User.objects.get(id=request.user.id)
            user.first_name = formulario.data['first_name']
            user.last_name = formulario.data['last_name']
            user.email = formulario.data['email']
            user.save()
            
            usuario = user.usuario_set.all()[0]
            data = formulario.data['dataNascimento'].split('/')
            usuario.dataNascimento = date(int(data[2]), int(data[1]), int(data[0]))
            usuario.endereco = formulario.data['endereco']
            usuario.cidade = Cidade.objects.get(id=formulario.data['cidade'])
            usuario.titulacao = Titulacao.objects.get(id=formulario.data['titulacao'])
            usuario.lattes = formulario.data['lattes']
            usuario.save()
            
            resultado = True
    else:
        user = User.objects.get(id=request.user.id)
        usuario = user.usuario_set.all()[0]

        formulario = FormularioUsuario(
            {
                'first_name' : user.first_name,
                'last_name' : user.last_name,
                'email' : user.email,
                'dataNascimento' : "%s/%0.2d/%s" % (
                    usuario.dataNascimento.day,
                    usuario.dataNascimento.month,
                    usuario.dataNascimento.year,
                ),
                'endereco' : usuario.endereco,
                'cidade' : usuario.cidade_id,
                'titulacao' : usuario.titulacao_id,
                'lattes' : usuario.lattes,
            }
        )

        formulario.errors.clear()

        del(formulario.fields['username'])
        del(formulario.fields['password'])
    
    return render_to_response(
        'adm/perfil.html',
        {
            'formulario' : formulario,
            'resultado' : resultado,
        },
        context_instance=RequestContext(request),
    )

def trabalho(request, id):
    """
    Função que mostra o trabalho de forma completa
    """
    try:
        trabalho = Trabalho.objects.get(id=id)
    except Exception, e:
        trabalho = Trabalho()
        pass    

    if trabalho.status_workflow() == 'publicado':
        return render_to_response(
            'trabalho.html',
            {'trabalho' : trabalho},
            context_instance=RequestContext(request)
        )

    return render_to_response(
        'trabalho.html', context_instance=RequestContext(request)
    )

@login_required()
@permission_required('bdig.colaborador')
def cadastrar_autor(request):
    """
    Função responsável pelo formulário de cadastro de autor na área do colaborador.
    """
    form = FormularioUsuario(request.POST or None)
    if form.is_valid():
        user = User()
        user.username = form.data['username']
        user.set_password(form.data['password'])
        user.first_name = form.data['first_name']
        user.last_name = form.data['last_name']
        user.email = form.data['email']
        user.is_staff = True
        user.save()

        group = Group.objects.filter(name='Autor')[0]
        user.groups.add(group)
        user.save()
        
        usuario = Usuario()
        usuario.user = user
        data = form.data['dataNascimento'].split('/')
        usuario.dataNascimento = date(int(data[2]), int(data[1]), int(data[0]))
        usuario.endereco = form.data['endereco']
        usuario.cidade = Cidade.objects.get(id=form.data['cidade'])
        usuario.titulacao = Titulacao.objects.get(id=form.data['titulacao'])
        usuario.lattes = form.data['lattes']
        usuario.save()
        
        request.user.message_set.create(message='O Autor foi adicionado com sucesso.')
        request.user.message_set.create(message='<a href="%s">Submeter Novo Trabalho.</a>' % reverse('bd_colaborador_submeter_trabalho'))
        request.user.message_set.create(message='<a href="%s">Voltar para a Página Inicial.</a>' % reverse('bd_adm'))
        
        form = FormularioUsuario()
    return render_to_response(
        'adm/colaborador/novo_autor.html',
        {'formulario' : form,},
        context_instance=RequestContext(request)
    )

@login_required()
@permission_required('bdig.colaborador')
def submeter_trabalho(request):
    """
    Função responsável pelo formulário de submissão de trabalho na área do colaborador.
    """
    form = FormularioCadastroTrabalho(request.POST or None)    
    form.fields['autor'].choices = [
        [x[0], x[2]+" "+x[3]]
        for x in User.objects.exclude(is_superuser=True).values_list()
        if not(x[0] == request.user.id) and Group.objects.get(name='Autor').user_set.filter(id=x[0])
    ]
    
    if form.is_valid():
        trabalho = Trabalho()
        trabalho.programa = Programa.objects.get(id=form.data['programa'])
        trabalho.titulo = form.data['titulo']
        trabalho.autor = User.objects.get(id=form.data['autor'])
        trabalho.colaborador = request.user
        trabalho.dataSubmissao = date.today()
        trabalho.save()
        
        request.user.message_set.create(message='O Trabalho foi adicionado com sucesso.')
        request.user.message_set.create(message='<a href="%s">Voltar para a pagina inicial.</a>' % reverse('bd_adm'))
        
        form = FormularioCadastroTrabalho()
    
    return render_to_response(
        'adm/colaborador/novo_trabalho.html',
        {'formulario' : form,},
        context_instance=RequestContext(request)
    )

@login_required()
@permission_required('bdig.autor')
def autor_correcao_trabalho(request, id):
    """
    Função responsável pelo formulário de alteração do trabalho na área do autor.
    """
    if request.method == 'POST':
        formulario = FormularioAutorCorrecaoTrabalho(request.POST, request.FILES)
        trabalho = Trabalho.objects.get(id=id)
        if formulario.data.has_key('_continue'):
        # caso o autor queira apenas salvar as modificações
            if formulario.is_valid():
                trabalho.titulo = formulario.data['titulo']
                trabalho.resumo = formulario.data['resumo']
                trabalho.title = formulario.data['title']
                trabalho.abstract = formulario.data['abstract']
                trabalho.palavrasChave = formulario.data['palavrasChave']
                trabalho.keywords = formulario.data['keywords']
                trabalho.anotacaoCorrecao = formulario.data['anotacaoCorrecao']
                if 'arquivo' in request.FILES:
                    trabalho.arquivo.save(
                        request.FILES['arquivo'].name,
                        request.FILES['arquivo'],
                        save = False,
                    )
                trabalho.save()
                
                request.user.message_set.create(message="O Trabalho foi modificado com sucesso.")
                request.user.message_set.create(message='<a href="%s">Voltar para a pagina inicial.</a>' % reverse('bd_adm'))
        else:
            # caso o autor queira enviar para correção
            if formulario.is_valid():
                trabalho.titulo = formulario.data['titulo']
                trabalho.resumo = formulario.data['resumo']
                trabalho.title = formulario.data['title']
                trabalho.abstract = formulario.data['abstract']
                trabalho.palavrasChave = formulario.data['palavrasChave']
                trabalho.keywords = formulario.data['keywords']
                if trabalho.workflow == 'cor_col_aut':
                    trabalho.workflow = 'cor_aut_col'
                elif trabalho.workflow == 'cor_pub_aut':
                    trabalho.workflow = 'cor_aut_pub'
                trabalho.anotacaoCorrecao = ''
                if 'arquivo' in request.FILES:
                    trabalho.arquivo.save(
                        request.FILES['arquivo'].name,
                        request.FILES['arquivo'],
                        save = False,
                    )       
                trabalho.save()
                
                correcao = Correcao()
                correcao.trabalho = trabalho
                correcao.usuario = request.user
                correcao.workflow = trabalho.workflow
                correcao.anotacao = formulario.data['anotacaoCorrecao']
                correcao.data_hora_envio = datetime.now()
                correcao.save()
                
                request.user.message_set.create(message="O Trabalho foi enviado para correção com sucesso.")
                
                return HttpResponseRedirect(reverse('bd_adm'))
    else:
        trabalho = Trabalho.objects.get(id=id)
        data = {
            'id' : trabalho.id,
            'titulo' : trabalho.titulo,
            'resumo' : trabalho.resumo,
            'title' : trabalho.title,
            'abstract' : trabalho.abstract,
            'palavrasChave' : trabalho.palavrasChave,
            'keywords' : trabalho.keywords,
            'anotacaoCorrecao' : trabalho.anotacaoCorrecao,
        }
        if trabalho.arquivo:
            files = {
                'arquivo' :
                    {
                        'filename': trabalho.arquivo.name,
                        'content': trabalho.arquivo.file,
                    },
            }
        else:
            files = {'arquivo' : {},}
        formulario = FormularioAutorCorrecaoTrabalho(data, files)
        formulario.errors.clear()
    return render_to_response(
        'adm/autor/correcao_trabalho.html',
        {
            'formulario' : formulario,
            'trabalho' : trabalho,
        },
        context_instance=RequestContext(request)
    )

@login_required()
@permission_required('bdig.autor')
def autor_trabalho_coautor(request, id_trabalho):
    object_list = CoAutor.objects.filter(trabalho__id = id_trabalho)
    return render_to_response(
        'adm/autor/relacao_coautores.html',
        {'object_list' : object_list,},
        context_instance=RequestContext(request)
    )

@login_required()
@permission_required('bdig.autor')
def autor_trabalho_coautor_add(request, id_trabalho):
    formulario = FormularioCadastroCoAutor(request.POST or None)            
    if formulario.is_valid():
        trabalho = Trabalho.objects.get(id=id_trabalho)
        coAutor = CoAutor()
        coAutor.trabalho = trabalho
        coAutor.nome = formulario.data['nome']
        coAutor.papel = formulario.data['papel']
        coAutor.save()
        
        request.user.message_set.create(message="Co-Autor foi cadastrado com sucesso.")
    return render_to_response(
        'adm/autor/cadastro_coautor.html',
        {
            'formulario' : formulario,
        },
        context_instance=RequestContext(request)
    )

@login_required()
@permission_required('bdig.autor')
def autor_trabalho_coautor_update(request, id_trabalho, id_coautor):
    resultado = False

    coAutor = CoAutor.objects.get(id=id_coautor)
    form = FormularioCadastroCoAutor(request.POST or None)
    
    if request.method == 'POST':
        if form.is_valid():
            coAutor.nome = form.data['nome']
            coAutor.papel = form.data['papel']
            coAutor.save()
            
            resultado = True
    else:
        form = FormularioCadastroCoAutor({
            'nome' : coAutor.nome,
            'papel' :coAutor.papel,
        })
    return render_to_response(
        'adm/autor/cadastro_coautor.html',
        {
            'formulario' : form,
            'resultado' : resultado,
        },
        context_instance=RequestContext(request)
    )

@login_required()
@permission_required('bdig.autor')
def autor_trabalho_coautor_delete(request, id_trabalho, id_coautor):
    try:
        coAutor = CoAutor.objects.get(id=id_coautor)
        coAutor.delete()
        return HttpResponse(u'Co-Autor Removido com Sucesso',)    
    except Exception, e:
        return HttpResponse(u'Erro, não foi possivel remover co-autor',)    

@login_required()
@permission_required('bdig.colaborador')
def colaborador_correcao_trabalho(request, id_trabalho):
    """
    Função responsável pelo formulário de alteração do trabalho na área do colaborador.
    """
    if request.method == 'POST':
        formulario = FormularioCorrecaoTrabalho(request.POST, request.FILES)
        trabalho = Trabalho.objects.get(id=id_trabalho)
        if formulario.data.has_key('_continue'):
        # caso o colaborador queira apenas salvar as modificações
            if formulario.is_valid():
                trabalho.anotacaoCorrecao = formulario.data['anotacaoCorrecao']
                if 'arquivo' in request.FILES:
                    trabalho.arquivo.save(
                        request.FILES['arquivo'].name,
                        request.FILES['arquivo'],
                        save = False,
                    )                
                trabalho.save()
                
                request.user.message_set.create(message='O Trabalho foi modificado com sucesso.')
                request.user.message_set.create(message='<a href="%s">Voltar para a pagina inicial.</a>' % reverse('bd_adm'))
        elif formulario.data.has_key('_cor_col_col'):
        # caso o colaborador queira transferir o trabalho para outro colaborador
            return HttpResponseRedirect(
                reverse(
                    'bd_colaborador_transferir_trabalho',
                    args=[id_trabalho,],
                )
            )
        elif formulario.data.has_key('_cor_col_aut'):
        # caso o colaborador queira enviar para o autor para correção
            if formulario.is_valid():
                trabalho.workflow = 'cor_col_aut'
                trabalho.anotacaoCorrecao = ''
                if 'arquivo' in request.FILES:
                    trabalho.arquivo.save(
                        request.FILES['arquivo'].name,
                        request.FILES['arquivo'],
                        save = False,
                    )
                trabalho.save()
                
                correcao = Correcao()
                correcao.trabalho = trabalho
                correcao.usuario = request.user
                correcao.workflow = 'cor_col_aut'
                correcao.anotacao = formulario.data['anotacaoCorrecao']
                correcao.data_hora_envio = datetime.now()
                correcao.save()
                
                request.user.message_set.create(message='O Trabalho foi enviado para o autor com sucesso.')
                
                return HttpResponseRedirect(reverse('bd_adm'))
        elif formulario.data.has_key('_cor_col_pub'):
        # caso o colaborador queira enviar para o publicador para correção
            if formulario.is_valid():
                trabalho.workflow = 'cor_col_pub'
                trabalho.dataConteudo = date.today()
                trabalho.anotacaoCorrecao = ''
                if 'arquivo' in request.FILES:
                    trabalho.arquivo.save(
                        request.FILES['arquivo'].name,
                        request.FILES['arquivo'],
                        save = False,
                    )
                trabalho.save()
                
                correcao = Correcao()
                correcao.trabalho = trabalho
                correcao.usuario = request.user
                correcao.workflow = 'cor_col_pub'
                correcao.anotacao = formulario.data['anotacaoCorrecao']
                correcao.data_hora_envio = datetime.now()
                correcao.save()
                
                request.user.message_set.create(message='O Trabalho foi enviado para o publicador com sucesso.')
                
                return HttpResponseRedirect(reverse('bd_adm'))
    else:
        trabalho = Trabalho.objects.get(id=id_trabalho)
        formulario = FormularioCorrecaoTrabalho(
            {
                'id' : trabalho.id,
                'anotacaoCorrecao' : trabalho.anotacaoCorrecao
            },
            {
                'arquivo' : {
                    'filename': trabalho.arquivo.name,
                    'content': trabalho.arquivo.file,
                }
            }
        )
        formulario.errors.clear()
    return render_to_response(
        'adm/colaborador/correcao_trabalho.html',
        {
            'formulario' : formulario,
            'trabalho' : trabalho,
        },
        context_instance=RequestContext(request),
    )

@login_required()
@permission_required('bdig.colaborador')
def colaborador_transferir_trabalho(request, id_trabalho):
    """
    Função responsável pelo formulário de transferencia de trabalho para outro colaborador.
    """
    form = FormularioTransferenciaTrabalho(request.POST or None)
    form.fields['colaborador'].choices = [
        [x[0], x[2]+" "+x[3]]
        for x in User.objects.exclude(is_superuser=True).values_list()
        if not(x[0] == request.user.id) and Group.objects.get(name='Colaborador').user_set.filter(id=x[0])
    ] 
    
    trabalho = Trabalho.objects.get(id=id_trabalho)

    if form.data.has_key('_continue'):
        if form.is_valid():
            trabalho.workflow = 'cor_aut_col'
            trabalho.colaborador = User.objects.get(id=form.data['colaborador'])
            trabalho.save()
            
            correcao = Correcao()
            correcao.trabalho = trabalho
            correcao.usuario = request.user
            correcao.workflow = 'tra_col_col'
            correcao.anotacao = form.data['anotacaoTransferencia'] 
            correcao.data_hora_envio = datetime.now()
            correcao.save()
            
            request.user.message_set.create(message="O Trabalho foi transferido com sucesso.")
            
            return HttpResponseRedirect(reverse('bd_adm'))
    elif form.data.has_key('_voltar'):
        return HttpResponseRedirect(
            reverse(
                'bd_colaborador_correcao_trabalho',
                args=[id_trabalho,],
            )
        )
    return render_to_response(
        'adm/colaborador/transferencia_trabalho.html',
        {
            'formulario' : form,
            'trabalho' : trabalho,
        },
        context_instance=RequestContext(request),
    )

@login_required()
@permission_required('bdig.publicador')
def publicador_correcao_trabalho(request, id_trabalho):
    """
    Função responsável pelo formulário de alteração do trabalho na área do publicador.
    """
    form = FormularioCorrecaoTrabalho(request.POST or None, request.FILES or None)
    trabalho = Trabalho.objects.get(id=id_trabalho)
        
    if form.data.has_key('_continue'):
    # caso o publicador queira apenas salvar as modificações
        if form.is_valid():
            trabalho.anotacaoCorrecao = form.data['anotacaoCorrecao']
            if 'arquivo' in request.FILES:
                trabalho.arquivo.save(
                    request.FILES['arquivo'].name,
                    request.FILES['arquivo'],
                    save = False,
                )
            trabalho.save()
            
            request.user.message_set.create(message='O Trabalho foi modificado com sucesso.')
            request.user.message_set.create(message='<a href="%s">Voltar para a pagina inicial.</a>' % reverse('bd_adm'))
    elif form.data.has_key('_cor_pub_aut'):
    # caso o publicador queira enviar para o autor para correção
        if form.is_valid():
            trabalho.workflow = 'cor_pub_aut'
            trabalho.anotacaoCorrecao = ''
            if 'arquivo' in request.FILES:
                trabalho.arquivo.save(
                    request.FILES['arquivo'].name,
                    request.FILES['arquivo'],
                    save = False,
                )
            trabalho.save()
            
            correcao = Correcao()
            correcao.trabalho = trabalho
            correcao.usuario = request.user
            correcao.workflow = 'cor_pub_aut'
            correcao.anotacao = form.data['anotacaoCorrecao']
            correcao.data_hora_envio = datetime.now()
            correcao.save()
            
            request.user.message_set.create(message='O Trabalho foi enviado para o autor com sucesso.')
            
            return HttpResponseRedirect(reverse('bd_adm'))
    elif form.data.has_key('publicado'):
    # caso o colaborador queira finalmente publicar um trabalho
        if form.is_valid():
            trabalho.workflow = 'publicado'
            trabalho.dataPublicacao = date.today()
            trabalho.publicador = request.user
            trabalho.anotacaoCorrecao = ''
            if 'arquivo' in request.FILES:
                trabalho.arquivo.save(
                    request.FILES['arquivo'].name,
                    request.FILES['arquivo'],
                    save = False,
                )
            trabalho.save()
            
            correcao = Correcao()
            correcao.trabalho = trabalho
            correcao.usuario = request.user
            correcao.workflow = 'publicado'
            correcao.anotacao = form.data['anotacaoCorrecao']
            correcao.data_hora_envio = datetime.now()
            correcao.save()
            
            request.user.message_set.create(message='O Trabalho foi PUBLICADO com sucesso.')
            
            return HttpResponseRedirect(reverse('bd_adm'))
    else:        
        form = FormularioCorrecaoTrabalho(
            {
                'id' : trabalho.id,
                'anotacaoCorrecao' : trabalho.anotacaoCorrecao,
            },
            {
                'arquivo' : {
                    'filename': trabalho.arquivo.name,
                    'content': trabalho.arquivo.file,
                },
            },
        )
        form.errors.clear()        
    return render_to_response(
        'adm/publicador/correcao_trabalho.html',
        {
            'formulario': form,
            'trabalho' : trabalho,
        },
        context_instance=RequestContext(request)
    )

@login_required()
def historico_trabalho(request, id_trabalho):
    trabalho = Trabalho.objects.get(id=id_trabalho)
    return render_to_response(
        'adm/historico_trabalho.html',
        {'object' : trabalho},
        context_instance=RequestContext(request)
    )
